import Koa from 'koa';
import Router from 'koa-router';
import { koaBody } from 'koa-body';
import cors from '@koa/cors';
import axios from 'axios';
import { fileURLToPath } from 'url';
import path from 'path';
import schedule from 'node-schedule';
import { database } from './db.js';
import { fetchAndInsertMovies, addDefaultCategories } from './tasks.js';
import jwt from 'jsonwebtoken';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const app = new Koa();
const router = new Router({
  prefix: '/api'
});

app.use(cors());
app.use(koaBody());

// JWT密钥
const JWT_SECRET = 'your-secret-key';

// 认证中间件
const authMiddleware = async (ctx, next) => {
  try {
    const authHeader = ctx.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      ctx.status = 401;
      ctx.body = { error: '未授权访问' };
      return;
    }

    const token = authHeader.substring(7);
    try {
      const decoded = jwt.verify(token, JWT_SECRET);
      ctx.state.user = decoded;
      await next();
    } catch (error) {
      ctx.status = 401;
      ctx.body = { error: '无效的token' };
    }
  } catch (error) {
    ctx.status = 500;
    ctx.body = { error: '服务器错误' };
  }
};

// 初始化数据
async function initializeData() {
  try {
    console.log('开始初始化数据...');
    
    // 添加默认分类
    await addDefaultCategories();
    
    // 获取现有电影数量
    const existingMovies = await database.getMovies();
    if (existingMovies.length === 0) {
      console.log('数据库中没有电影，开始获取电影数据...');
      await fetchAndInsertMovies();
    } else {
      console.log(`数据库中已有 ${existingMovies.length} 部电影`);
    }
    
    console.log('数据初始化完成');
  } catch (error) {
    console.error('数据初始化失败:', error);
  }
}

// 定时任务：更新电影数据
async function updateMovieData() {
  try {
    console.log('开始更新电影数据...');
    await fetchAndInsertMovies();
    console.log('电影数据更新完成');
  } catch (error) {
    console.error('更新电影数据失败:', error);
  }
}

// 定时任务：数据备份
async function backupData() {
  try {
    console.log('开始备份数据...');
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const backupDir = path.join(__dirname, '../backup');
    
    // 创建备份目录
    // await fs.mkdir(backupDir, { recursive: true });
    
    // 备份电影数据
    const movies = await database.getMovies();
    // await fs.writeFile(path.join(backupDir, `movies-${timestamp}.json`), JSON.stringify(movies, null, 2));
    
    // 备份分类数据
    const categories = await database.getCategories();
    // await fs.writeFile(path.join(backupDir, `categories-${timestamp}.json`), JSON.stringify(categories, null, 2));
    
    console.log('数据备份完成');
    
    // 清理旧备份文件（保留最近7天的备份）
    // const files = await fs.readdir(backupDir);
    // const now = Date.now();
    // const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000;
    
    // for (const file of files) {
    //   const filePath = path.join(backupDir, file);
    //   const stats = await fs.stat(filePath);
    //   if (stats.mtimeMs < sevenDaysAgo) {
    //     await fs.unlink(filePath);
    //     console.log(`删除旧备份文件: ${file}`);
    //   }
    // }
  } catch (error) {
    console.error('数据备份失败:', error);
  }
}

// 设置定时任务
function setupScheduledTasks() {
  // 每天凌晨3点更新电影数据
  schedule.scheduleJob('0 3 * * *', updateMovieData);
  
  // 每天凌晨2点进行数据备份
  schedule.scheduleJob('0 2 * * *', backupData);
  
  console.log('定时任务已设置');
}

// 工具函数：转换图片URL为代理URL
const convertToProxyUrl = (imageUrl) => {
  if (!imageUrl) return '';
  // 如果已经是完整的URL，则返回代理URL
  if (imageUrl.startsWith('http://') || imageUrl.startsWith('https://')) {
    return `http://localhost:3000/api/proxy-image?url=${encodeURIComponent(imageUrl)}`;
  }
  return imageUrl;
};

// 工具函数：处理电影数据，转换图片URL
const processMovieData = (movie) => {
  if (Array.isArray(movie)) {
    return movie.map(m => {
      const processed = {
        ...m,
        poster: convertToProxyUrl(m.poster)
      };
      console.log('处理后的电影数据:', processed);
      return processed;
    });
  }
  const processed = {
    ...movie,
    poster: convertToProxyUrl(movie.poster)
  };
  console.log('处理后的电影数据:', processed);
  return processed;
};

// 初始化数据和设置定时任务
initializeData();
setupScheduledTasks();

// 认证相关路由
router.post('/auth/login', async (ctx) => {
  try {
    const { username, password } = ctx.request.body;
    const isValid = await database.verifyAdmin(username, password);
    
    if (isValid) {
      // 生成JWT token
      const token = jwt.sign({ username }, JWT_SECRET, { expiresIn: '24h' });
      ctx.body = { token };
    } else {
      ctx.status = 401;
      ctx.body = { error: '用户名或密码错误' };
    }
  } catch (error) {
    console.error('登录失败:', error);
    ctx.status = 500;
    ctx.body = { error: '登录失败' };
  }
});

// 获取所有电影
router.get('/movies', async (ctx) => {
  try {
    const page = parseInt(ctx.query.page) || 1;
    const pageSize = parseInt(ctx.query.pageSize) || 12;
    const category = ctx.query.category || '';

    if (isNaN(page) || isNaN(pageSize) || page < 1 || pageSize < 1) {
      ctx.status = 400;
      ctx.body = { error: '无效的分页参数' };
      return;
    }

    const result = await database.getMovies(page, pageSize, category);
    // 处理每个电影的图片URL
    result.movies = result.movies.map(movie => ({
      ...movie,
      poster: convertToProxyUrl(movie.poster) // 使用代理URL
    }));
    ctx.body = result;
  } catch (error) {
    console.error('获取电影列表失败:', error);
    ctx.status = 500;
    ctx.body = { error: '获取电影数据失败' };
  }
});

// 添加新电影
router.post('/movies', authMiddleware, async (ctx) => {
  try {
    const movieData = {
      id: Date.now().toString(),
      ...ctx.request.body,
      dateAdded: new Date().toISOString()
    };
    const savedMovie = await database.addMovie(movieData);
    ctx.body = processMovieData(savedMovie);
  } catch (error) {
    ctx.status = 500;
    ctx.body = { error: '添加电影失败' };
  }
});

// 更新电影
router.put('/movies/:id', authMiddleware, async (ctx) => {
  try {
    const movie = await database.getMovie(ctx.params.id);
    if (!movie) {
      ctx.status = 404;
      ctx.body = { error: '电影不存在' };
      return;
    }
    const updatedMovie = await database.updateMovie(ctx.params.id, ctx.request.body);
    ctx.body = processMovieData(updatedMovie);
  } catch (error) {
    ctx.status = 500;
    ctx.body = { error: '更新电影失败' };
  }
});

// 删除电影
router.delete('/movies/:id', authMiddleware, async (ctx) => {
  try {
    await database.deleteMovie(ctx.params.id);
    ctx.body = { message: '删除成功' };
  } catch (error) {
    ctx.status = 500;
    ctx.body = { error: '删除电影失败' };
  }
});

// 获取所有分类
router.get('/categories', async (ctx) => {
  try {
    ctx.body = await database.getCategories();
  } catch (error) {
    ctx.status = 500;
    ctx.body = { error: '获取分类数据失败' };
  }
});

// 添加新分类
router.post('/categories', authMiddleware, async (ctx) => {
  try {
    const categoryData = {
      id: Date.now().toString(),
      name: ctx.request.body.name
    };
    ctx.body = await database.addCategory(categoryData);
  } catch (error) {
    ctx.status = 500;
    ctx.body = { error: '添加分类失败' };
  }
});

// 删除分类
router.delete('/categories/:id', authMiddleware, async (ctx) => {
  try {
    await database.deleteCategory(ctx.params.id);
    ctx.body = { message: '删除成功' };
  } catch (error) {
    ctx.status = 500;
    ctx.body = { error: '删除分类失败' };
  }
});

// 图片代理
router.get('/proxy-image', async (ctx) => {
  const imageUrl = ctx.query.url;
  if (!imageUrl) {
    ctx.status = 400;
    ctx.body = { error: '未提供图片URL' };
    return;
  }

  try {
    const response = await axios({
      url: imageUrl,
      method: 'GET',
      responseType: 'arraybuffer'
    });

    // 设置响应头
    ctx.set({
      'Content-Type': response.headers['content-type'],
      'Cache-Control': 'public, max-age=31536000', // 缓存一年
      'Access-Control-Allow-Origin': '*'
    });

    // 设置响应体为图片数据
    ctx.body = response.data;
  } catch (error) {
    console.error('代理图片失败:', error);
    ctx.status = 500;
    ctx.body = { error: '获取图片失败' };
  }
});

app.use(router.routes()).use(router.allowedMethods());

// 添加错误处理
app.on('error', (err, ctx) => {
  console.error('服务器错误:', err);
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});
